﻿/**
 * @namespace global The default, global namespace.
 * This is the extended description of the global namespace.
 */

/**
 * Provides support for creation of arrays of any data type.
 * <p>After an array is created, the individual elements of the array can be accessed using [ ] notation, for example:</p>
 * <pre>
 * var my_array = new Array();
 * for (i = 0; i < 10; i++)
 * {
 *     my_array[i] = i;
 * }
 * x = my_array[4];
 * </pre>
 * <p>Since arrays in Microsoft JScript are zero-based, the last statement in the preceding example accesses the
 * fifth element of the array. That element contains the value 4.</p>
 * <p>If only one argument is passed to the Array constructor, and the argument is a number, it must be an unsigned
 * 32-bit integer (< approximately four billion). That value then becomes the size of the array. If the value is a
 * number, but is less than zero or is not an integer, a run-time error occurs.</p>
 * <p>If a single value is passed to the Array constructor, and it is not a number, the length property is set to 1,
 * and the value of the only element becomes the single, passed-in argument.</p>
 * <p>Notice that JScript arrays are sparse arrays, that is, although you can allocate an array with many elements,
 * only the elements that actually contain data exist. This reduces the amount of memory used by the array.</p>
 * @syntax arrayObj = new Array()
 * @syntax arrayObj = new Array([size])
 * @syntax arrayObj = new Array([element0, [element1[, ...[, elementN]]]])
 * @param {Number} size The size of the array. As arrays are zero-based, created elements will have indexes from zero to size -1. Optional.
 * @arguments {Object} [0-n] Optional elements to place in the array. This creates an array with n + 1 elements, and a length of n + 1.
 * Using this syntax, you must supply more than one element. Optional.
 * @class
 */
function Array(size)
{
}

/**
 * An integer value one higher than the highest element defined in an array.
 * @type {Number}
 */
Array.prototype.length = 0;

/**
 * Gets a new array consisting of a combination of two or more arrays.
 * @syntax array1.concat([item1, [item2[, ...[, itemN]]]])
 * @arguments {Object} [0-n] Additional items to add to the end of this array. Optional.
 * @return {Array} The new combined array.
 */
Array.prototype.concat = function ()
{
}

/**
 * Gets a value consisting of all the elements of an array concatenated together and separated by the specified separator character.
 * @param {String} separator A String object used to separate one element of an array from the next in the resulting String object.
 * If omitted, the array elements are separated with a comma.
 * @return {String} All values from the array converted to a string and joined by separator.
 */
Array.prototype.join = function (separator)
{
}

/**
 * Removes the last element from an array and returns it.
 * @return {Object} The last element from the array
 */
Array.prototype.pop = function ()
{
}

/**
 * Appends new elements to an array, and returns the new length of the array.
 * @syntax arrayObj.push([item1 [item2 [... [itemN ]]]])
 * @arguments {Object} [0-n] New elements of the Array
 * @return {Number} The new length of the array
 */
Array.prototype.push = function ()
{
}

/**
 * Gets an Array object with the elements reversed.
 * @return {Object} Array object with the elements reversed.
 */
Array.prototype.reverse = function ()
{
}

/**
 * Removes the first element from an array and returns it.
 * @return {Object} First element from an array
 */
Array.prototype.shift = function ()
{
}

/**
 * Gets a section of an array.
 * @param {Number} start The index to the beginning of the specified portion of arrayObj.
 * @param {Number} end The index to the end of the specified portion of arrayObj. Optional.
 * @return {Array} Section of an array from <code>start</code> to <code>end</code>.
 */
Array.prototype.slice = function (start, end)
{
}

/**
 * Gets an Array object with the elements sorted.
 * The sort method sorts the Array object in place; no new Array object is created during execution.<br/>
 * If you supply a function in the sortFunction argument, it must return one of the following values:
 * <ul>
 * <li>A negative value if the first argument passed is less than the second argument.</li>
 * <li>Zero if the two arguments are equivalent.</li>
 * <li>A positive value if the first argument is greater than the second argument.</li>
 * </ul>
 * @param {Function} sortFunction The name of the function used to determine the order of the elements.
 * If omitted, the elements are sorted in ascending, ASCII character order. Optional.
 * @return {Array} The current array with element sorted.
 */
Array.prototype.sort = function (sortFunction)
{
}

/**
 * Removes elements from an array and, if necessary, inserts new elements in their place, returning the deleted elements.
 * The splice method modifies arrayObj by removing the specified number of elements from position start and inserting new elements.
 * The deleted elements are returned as a new array object.
 * @syntax arrayObj.splice(start, deleteCount, [item1[, item2[, ... [,itemN]]]])
 * @param {Number} start The zero-based location in the array from which to start removing elements.
 * @param {Number} deleteCount The number of elements to remove.
 * @arguments {Object} [0-n] Elements to insert into the array in place of the deleted elements. Optional.
 * @return {Array} The elements deleted from the array.
 */
Array.prototype.splice = function (start, deleteCount)
{
}

/**
 * Gets an array with specified elements inserted at the beginning.
 * @syntax arrayObj.unshift([item1[, item2 [, ... [, itemN]]]])
 * @arguments {Object} [0-n] Elements to insert at the start of the Array. Optional.
 */
Array.prototype.unshift = function ()
{
}

/**
 * Creates a new Boolean value.
 * @class
 */
function Boolean()
{
}

/**
 * Enables basic storage and retrieval of dates and times.
 * <p>A Date object contains a number representing a particular instant in time to within a millisecond.
 * If the value of an argument is greater than its range or is a negative number, other stored values are modified accordingly.
 * For example, if you specify 150 seconds, JScript redefines that number as two minutes and 30 seconds.</p>
 * <p>If the number is NaN, the object does not represent a specific instant of time. If you pass no parameters to the Date object,
 * it is initialized to the current time (UTC). A value must be given to the object before you can use it.</p>
 * <p>The range of dates that can be represented in a Date object is approximately 285,616 years on either side of January 1, 1970.
 * The Date object has two static methods that are called without creating a Date object: {@see parse} and {@see UTC}.</p>
 * @syntax dateObj = new Date()
 * @syntax dateObj = new Date(dateVal)
 * @syntax dateObj = new Date(year, month, date[, hours[, minutes[, seconds[, ms]]]])
 * @param {Object} dateVal If a numeric value, dateVal represents the number of milliseconds in Universal Coordinated Time
 * between the specified date and midnight January 1, 1970. If a string, dateVal is parsed according to the rules in the
 * parse method. The dateVal argument can also be a VT_DATE value as returned from some ActiveX® objects.
 * @param {Number} year The full year, for example, 1976 (and not 76).<br/>
 * @param {Number} month The month as an integer between 0 and 11 (January to December).<br/>
 * @param {Number} date The date as an integer between 1 and 31.<br/>
 * @param {Number} hours Must be supplied if minutes is supplied. An integer from 0 to 23 (midnight to 11pm) that specifies the hour. Optional.<br/>
 * @param {Number} minutes Must be supplied if seconds is supplied. An integer from 0 to 59 that specifies the minutes. Optional.<br/>
 * @param {Number} seconds Must be supplied if milliseconds is supplied. An integer from 0 to 59 that specifies the seconds. Optional.<br/>
 * @param {Number} milliseconds An integer from 0 to 999 that specifies the milliseconds.
 * @class
 */
function Date(dateVal)
{
}

/**
 * Gets the day of the month value in a Date object using local time.
 * @return {Number} The day of the month value in a Date object
 */
Date.prototype.getDate = function ()
{
}

/**
 * Gets the day of the week value in a Date object using local time.
 * @return {Number} The day of the week value in a Date object
 */
Date.prototype.getDay = function ()
{
}

/**
 * Gets the year value in the Date object using local time.
 * @return {Number} The year value in a Date object
 */
Date.prototype.getFullYear = function ()
{
}

/**
 * Gets the hours value in a Date object using local time.
 * @return {Number} The hours value in a Date object
 */
Date.prototype.getHours = function ()
{
}

/**
 * Gets the milliseconds value in a Date object using local time.
 * @return {Number} The milliseconds value in a Date object
 */
Date.prototype.getMilliseconds = function ()
{
}

/**
 * Gets the minutes value in a Date object using local time.
 * @return {Number} The day of the week value in a Date object
 */
Date.prototype.getMinutes = function ()
{
}

/**
 * Gets the month value in the Date object using local time.
 * The getMonth method returns an integer between 0 and 11 indicating the month value in the Date object.
 * The integer returned is not the traditional number used to indicate the month. It is one less.
 * If "Jan 5, 1996 08:47:00" is stored in a Date object, getMonth returns 0.
 * @return {Number} The month value in a Date object
 */
Date.prototype.getMonth = function ()
{
}

/**
 * Gets the seconds value in a Date object using local time.
 * @return {Number} The seconds value in a Date object
 */
Date.prototype.getSeconds = function ()
{
}

/**
 * Gets the time value in a Date object.
 * The getTime method returns an integer value representing the number of milliseconds between midnight, January 1, 1970
 * and the time value in the Date object. The range of dates is approximately 285,616 years from either side of midnight,
 * January 1, 1970. Negative numbers indicate dates prior to 1970.
 * @return {Number} The time value in a Date object
 */
Date.prototype.getTime = function ()
{
}

/**
 * Gets the difference in minutes between the time on the host computer and Universal Coordinated Time (UTC).
 * @return {Number} difference in minutes between the time on the host computer and Universal Coordinated Time (UTC).
 */
Date.prototype.getTimezoneOffset = function ()
{
}

/**
 * Gets the date in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The date in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCDate = function ()
{
}

/**
 * Gets the day of the week value in a Date object using Universal Coordinated Time (UTC).
 * The value returned by the getUTCDay method is an integer between 0 and 6 representing the day of the week and corresponds
 * to a day of the week where first day (0) is Sunday.
 * @return {Number} The the day of the week in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCDay = function ()
{
}

/**
 * Gets the year value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The year value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCFullYear = function ()
{
}

/**
 * Gets the hours value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The hours value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCHours = function ()
{
}

/**
 * Gets the milliseconds value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The milliseconds value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCMilliseconds = function ()
{
}

/**
 * Gets the minutes value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The minutes value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCMinutes = function ()
{
}

/**
 * Gets the month value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The month value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCMonth = function ()
{
}

/**
 * Gets the seconds value in a Date object using Universal Coordinated Time (UTC).
 * @return {Number} The seconds value in a Date object using Universal Coordinated Time (UTC).
 */
Date.prototype.getUTCSeconds = function ()
{
}

/**
 * Gets the VT_DATE value in a Date object.
 * The getVarDate method is used when interacting with COM objects, ActiveX® objects or other objects
 * that accept and return date values in VT_DATE format, such as Visual Basic and VBScript.
 * The actual format is dependent on regional settings and should not be replied upon within JScript.
 * @return {Object} VT_DATE value in a Date object
 */
Date.prototype.getVarDate = function ()
{
}

/**
 * Gets the year value in a Date object.
 * @return {Number} The year value in a Date object.
 */
Date.prototype.getYear = function ()
{
}

/**
 * Sets the numeric date of the Date object using local time.
 * @param {Number} date A numeric value equal to the numeric date.
 */
Date.prototype.setDate = function (date)
{
}

/**
 * Sets the year value in the Date object using local time.
 * @param {Number} year A numeric value equal to the year.
 * @param {Number} month A numeric value equal to the month. Must be supplied if the following argument is used. Optional.
 * @param {Number} date A numeric value equal to the date. Optional.
 */
Date.prototype.setFullYear = function (year, month, date)
{
}

/**
 * Sets the hour value in the Date object using local time.
 * @param {Number} hours A numeric value equal to the hours value.
 * @param {Number} minutes A numeric value equal to the minutes value. Must be supplied if either of the following arguments is used. Optional.
 * @param {Number} seconds A numeric value equal to the seconds value. Must be supplied if the following argument is used. Optional.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setHours = function (hours, minutes, seconds, milliseconds)
{
}

/**
 * Sets the milliseconds value in the Date object using local time.
 * @param {Number} milliseconds A numeric value equal to the millisecond value.
 */
Date.prototype.setMilliseconds = function (milliseconds)
{
}

/**
 * Sets the minutes value in the Date object using local time.
 * @param {Number} minutes A numeric value equal to the minutes value.
 * @param {Number} seconds A numeric value equal to the seconds value. Must be supplied if the following argument is used. Optional.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setMinutes = function (minutes, seconds, milliseconds)
{
}

/**
 * Sets the month value in the Date object using local time.
 * @param {Number} month A numeric value equal to the month.
 */
Date.prototype.setMonth = function (month)
{
}

/**
 * Sets the seconds value in the Date object using local time.
 * @param {Number} seconds A numeric value equal to the seconds value.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setSeconds = function (seconds, milliseconds)
{
}

/**
 * Sets the date and time value in the Date object.
 * @param {Number} milliseconds A numeric value equal to the numeric date.
 */
Date.prototype.setTime = function (milliseconds)
{
}

/**
 * Sets the numeric date in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} date A numeric value equal to the numeric date.
 */
Date.prototype.setUTCDate = function (date)
{
}

/**
 * Sets the year value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} year A numeric value equal to the year.
 * @param {Number} month A numeric value equal to the month. Must be supplied if the following argument is used. Optional.
 * @param {Number} date A numeric value equal to the date. Optional.
 */
Date.prototype.setUTCFullYear = function (year, month, date)
{
}

/**
 * Sets the hours value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} hours A numeric value equal to the hours value.
 * @param {Number} minutes A numeric value equal to the minutes value. Must be supplied if either of the following arguments is used. Optional.
 * @param {Number} seconds A numeric value equal to the seconds value. Must be supplied if the following argument is used. Optional.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setUTCHours = function (hours, minutes, seconds, milliseconds)
{
}

/**
 * Sets the milliseconds value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setUTCMilliseconds = function (milliseconds)
{
}

/**
 * Sets the minutes value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} minutes A numeric value equal to the minutes value.
 * @param {Number} seconds A numeric value equal to the seconds value. Must be supplied if the following argument is used. Optional.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setUTCMinutes = function (minutes, seconds, milliseconds)
{
}

/**
 * Sets the month value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} month A numeric value equal to the month.
 */
Date.prototype.setUTCMonth = function (month)
{
}

/**
 * Sets the seconds value in the Date object using Universal Coordinated Time (UTC).
 * @param {Number} seconds A numeric value equal to the seconds value.
 * @param {Number} milliseconds A numeric value equal to the milliseconds value. Optional.
 */
Date.prototype.setUTCSeconds = function (seconds, milliseconds)
{
}

/**
 * Sets the year value in the Date object.
 * @param {Number} year A numeric value equal to the year.
 */
Date.prototype.setYear = function (year)
{
}

/**
 * Gets a date converted to a string using Greenwich Mean Time(GMT).
 * The format of the return value is as follows: "05 Jan 1996 00:00:00 GMT."
 * @return {String} date converted to a string using Greenwich Mean Time(GMT).
 */
Date.prototype.toGMTString = function ()
{
}

/**
 * Gets a date converted to a string using the current locale.
 * For example, in the United States, toLocaleString returns "01/05/96 00:00:00" for January 5.
 * In Europe, it returns "05/01/96 00:00:00" for the same date, as European convention puts the day before the month.<br/>
 * toLocaleString should only be used to display results to a user; it should never be used as the basis for computation within
 * a script as the returned result is machine-specific.
 * @return {String} date converted to a string using the current locale.
 */
Date.prototype.toLocaleString = function ()
{
}

/**
 * Gets a date converted to a string using Universal Coordinated Time (UTC).<br/>
 * The toUTCString method returns a String object that contains the date formatted using UTC convention in a convenient, easily read form.
 * @return {String} date converted to a string using Universal Coordinated Time (UTC).
 */
Date.prototype.toUTCString = function ()
{
}

/**
 * Parses a string containing a date, and returns the number of milliseconds between that date and midnight, January 1, 1970.
 * <p>The following rules govern what the parse method can successfully parse:
 * <ul>
 * <li>Short dates can use either a "/" or "-" date separator, but must follow the month/day/year format, for example "7/20/96".</li>
 * <li>Long dates of the form "July 10 1995" can be given with the year, month, and day in any order, and the year in 2-digit or 4-digit form.
 * If you use the 2-digit form, the year must be greater than or equal to 70.</li>
 * <li>Any text inside parentheses is treated as a comment. These parentheses may be nested.</li>
 * <li>Both commas and spaces are treated as delimiters. Multiple delimiters are permitted.</li>
 * <li>Month and day names must have two or more characters. Two character names that are not unique are resolved as the last match.
 * For example, "Ju" is resolved as July, not June.</li>
 * <li>The stated day of the week is ignored if it is incorrect given the remainder of the supplied date. For example, "Tuesday November 9 1996"
 * is accepted and parsed even though that date actually falls on a Friday. The resulting Date object contains "Friday November 9 1996".</li>
 * <li>JScript handles all standard time zones, as well as Universal Coordinated Time (UTC) and Greenwich Mean Time (GMT).</li>
 * <li>Hours, minutes, and seconds are separated by colons, although all need not be specified. "10:", "10:11", and "10:11:12" are all valid.</li>
 * <li>If the 24-hour clock is used, it is an error to specify "PM" for times later than 12 noon. For example, "23:15 PM" is an error.</li>
 * <li>A string containing an invalid date is an error. For example, a string containing two years or two months is an error.</li>
 * </ul>
 * @param {Object} dateValue The required dateVal argument is either a string containing a date in a format such as
 * "Jan 5, 1996 08:47:00" or a VT_DATE value retrieved from an ActiveX® object or other object.
 * @return {String} The number of milliseconds between midnight, January 1, 1970 UTC and the parsed date
 */
Date.parse = function (dateValue)
{
}

/**
 * Gets the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the supplied date.
 * This return value can be used in the setTime method and in the Date object constructor. If the value of an argument is greater than its range,
 * or is a negative number, other stored values are modified accordingly. For example, if you specify 150 seconds, JScript redefines that number
 * as two minutes and 30 seconds.
 * @param {Number} year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then
 * year is assumed to be 1900 + year.
 * @param {Number} month The month as an integer between 0 and 11 (January to December).
 * @param {Number} day The date as an integer between 1 and 31.
 * @param {Number} hours Must be supplied if minutes is supplied. An integer from 0 to 23 (midnight to 11pm) that specifies the hour. Optional.
 * @param {Number} minutes Must be supplied if seconds is supplied. An integer from 0 to 59 that specifies the minutes. Optional.
 * @param {Number} seconds Must be supplied if milliseconds is supplied. An integer from 0 to 59 that specifies the seconds. Optional.
 * @param {Number} milliseconds An integer from 0 to 999 that specifies the milliseconds. Optional.
 * @return {String} The number of milliseconds between midnight, January 1, 1970 UTC and the supplied date
 */
Date.UTC = function (year, month, day, hours, minutes, seconds, milliseconds)
{
}


/**
 * Contains information about errors.
 * <p>Whenever a run-time error occurs, an instance of the Error object is created to describe the error.
 * This instance has two intrinsic properties that contain the description of the error (description property) and
 * the error number (number property).</p>
 * <p>An error number is a 32-bit value. The upper 16-bit word is the facility code, while the lower word is the actual error code.</p>
 * <p>Error objects can also be explicitly created, using the syntax shown above, or thrown using the throw statement. In both cases,
 * you can add any properties you choose to expand the capability of the Error object.</p>
 * <p>Typically, the local variable that is created in a try...catch statement refers to the implicitly created Error object.
 * As a result, you can use the error number and description in any way you choose.</p>
 * @param {Number} number Numeric value assigned to an error. Zero if omitted. Optional.
 * @param {String} message Brief string that describes an error. Empty string if omitted. Optional.
 * @class
 */
function Error(number, message)
{
}

/**
 * Gets or sets the descriptive string associated with a specific error.
 * @type {String}
 */
Error.prototype.message;

/**
 * Gets or sets the numeric value associated with a specific error. The Error object's default property is number.
 * @type {Number}
 */
Error.prototype.number;


/**
 * Creates a new function.
 * @class
 */
function Function()
{
}

/**
 * Gets the arguments object for the currently executing Function object.
 * @type {Object}
 */
Function.prototype.arguments =
{
	/**
	 * Gets the number of arguments in the <c>arguments</c> object.
	 */
	length: 0
};

/**
 * Gets a reference to the function that invoked the current function.
 * @type {Function}
 */
Function.prototype.caller = new Function();





/**
 * The initial value of Number.POSITIVE_INFINITY.
 * @type {Object}
 */
var Infinity;

/**
 * A special value that indicates an arithmetic expression returned a value that was not a number.
 * @type {Object}
 */
var NaN;

/**
 * Encodes String objects so they can be read on all computers
 * <p>The escape method returns a string value (in Unicode format) that contains the contents of charstring.
 * All spaces, punctuation, accented characters, and any other non-ASCII characters are replaced with %xx encoding,
 * where xx is equivalent to the hexadecimal number representing the character. For example, a space is returned as "%20."</p>
 * <p>Characters with a value greater than 255 are stored using the %uxxxx format</p>
 * @param {String} string String object or literal to be encoded
 * @return {String} encoded string
 */
function escape(string)
{
}

/**
 * Evaluates JScript code and executes it.
 * <p>The eval function allows dynamic execution of JScript source code</p>
 * <p>The code passed to the eval method is executed in the same context as the call to the eval method.</p>
 * @param {String} codeString The string of code to be evaluated. This string is parsed by the JScript parser and executed.
 */
function eval(codeString)
{
}

/**
 * Gets a Boolean value that indicates if a supplied number is finite.
 * @param {Number} number Any numeric value
 * @return {Boolean} value that indicates if a supplied number is finite.
 */
function isFinite(number)
{
}

/**
 * Gets a Boolean value that indicates whether a value is the reserved value NaN (not a number).
 * @param {Object} value The value to be tested against NAN
 * @return {Boolean} value that indicates if a supplied value is not a number.
 */
function isNaN(value)
{
}

/**
 * Gets a floating-point number converted from a string.
 * <p>The parseFloat method returns a numerical value equal to the number contained in <code>value</code>.
 * If no prefix of <code>value</code> can be successfully parsed into a floating-point number, NaN (not a number) is returned.</p>
 * @param {String} value A string that contains a floating-point number
 * @return {Number} A floating-point number converted from a string.
 */
function parseFloat(value)
{
}

/**
 * Gets an integer converted from a string.
 * <p>The parseInt method returns an integer value equal to the number contained in <code>value</code>.
 * If no prefix of <code>value</code> can be successfully parsed into an integer, NaN (not a number) is returned.</p>
 * @param {String} value A string to convert into a number.
 * @param {Number} radix A value between 2 and 36 indicating the base of the number contained in numString.
 * If not supplied, strings with a prefix of '0x' are considered hexadecimal and strings with a prefix of '0' are considered octal.
 * All other strings are considered decimal.
 * @return {Number} An integer converted from a string.
 */
function parseInt(value, radix)
{
}

/**
 * Decodes String objects encoded with the escape method.
 * <p>The unescape method returns a string value that contains the contents of charstring. All characters encoded with the %xx
 * hexadecimal form are replaced by their ASCII character set equivalents.</p>
 * <p>Characters encoded in %uxxxx format (Unicode characters) are replaced with the Unicode character with hexadecimal encoding xxxx.</p>
 * @param {String} string A String object or literal to be decoded.
 * @return {String} decoded string
 */
function unescape(string)
{
}




/**
 * An object representation of the number data type and placeholder for numeric constants.
 * @param {String} value The numeric value of the Number object being created.
 * @class
 */
function Number(value)
{
}

/**
 * The largest number representable in JScript. Equal to approximately 1.79E+308
 * @type {Number}
 */
Number.MAX_VALUE = Number.MAX_VALUE;

/**
 * The number closest to zero representable in JScript. Equal to approximately 5.00E-324.
 * @type {Number}
 */
Number.MIN_VALUE = Number.MIN_VALUE;

/**
 * A special value that indicates an arithmetic expression returned a value that was not a number
 * @type {Object}
 */
Number.NaN = Number.NaN;

/**
 * A value more negative than the largest negative number (-Number.MAX_VALUE) representable in JScript.
 * @type {Number}
 */
Number.NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;

/**
 * A value larger than the largest number (Number.MAX_VALUE) that can be represented in JScript.
 * @type {Number}
 */
Number.POSITIVE_INFINITY = Number.POSITIVE_INFINITY;

/**
 * Gets the value of the current number converted to a string using the current locale settings for formatting.
 * @return {String} The number converted to a locale string.
 */
Number.prototype.toLocaleString = function ()
{
}




/**
 * An intrinsic object that provides basic mathematics functionality and constants.
 * @class
 */
function Math()
{
}

/**
 * The Euler's constant, the base of natural logarithms. The E property is approximately equal to 2.718.
 * @type {Number}
 */
Math.E = Math.E;

/**
 * The natural logarithm of 2.
 * @type {Number}
 */
Math.LN2 = Math.LN2;

/**
 * The natural logarithm of 10.
 * @type {Number}
 */
Math.LN10 = Math.LN10;

/**
 * The base-2 logarithm of e, Euler's constant.
 * @type {Number}
 */
Math.LOG2E = Math.LOG2E;

/**
 * The base-10 logarithm of e, Euler's constant.
 * @type {Number}
 */
Math.LOG10E = Math.LOG10E;

/**
 * The ratio of the circumference of a circle to its diameter, approximately 3.141592653589793.
 * @type {Number}
 */
Math.PI = Math.PI;

/**
 * The square root of 0.5, or one divided by the square root of 2.
 * @type {Number}
 */
Math.SQRT1_2 = Math.SQRT1_2;

/**
 * The square root of 2.
 * @type {Number}
 */
Math.SQRT2 = Math.SQRT2;

/**
 * Gets the absolute value of a number.
 * @param {Number} number A numeric expression for which the absolute value is needed
 * @return {Number} The absolute value of a number.
 */
Math.abs = function (number)
{
}

/**
 * Gets the arccosine of a number.
 * @param {Number} number A numeric expression for which the arccosine value is needed
 * @return {Number} The arccosine of a number.
 */
Math.acos = function (number)
{
}

/**
 * Gets the arcsine of a number.
 * @param {Number} number A numeric expression for which the arcsine value is needed
 * @return {Number} The arcsine of a number.
 */
Math.asin = function (number)
{
}

/**
 * Gets the arctangent of a number.
 * @param {Number} number A numeric expression for which the arctangent value is needed
 * @return {Number} The arctangent of a number.
 */
Math.atan = function (number)
{
}

/**
 * Gets the angle (in radians) from the X axis to a point (y,x).
 * @param {Number} x A numeric expression representing the cartesian x-coordinate
 * @param {Number} y A numeric expression representing the cartesian y-coordinate
 * @return {Number} The angle (in radians) from the X axis to a point (y,x).
 */
Math.atan2 = function (x, y)
{
}

/**
 * Gets the smallest integer greater than or equal to its numeric argument.
 * @param {Number} number Any numeric expression
 * @return {Number} The smallest integer greater than or equal to its numeric argument.
 */
Math.ceil = function (number)
{
}

/**
 * Gets the cosine of a number.
 * @param {Number} number A numeric expression for which the cosine value is needed
 * @return {Number} The cosine of a number.
 */
Math.cos = function (number)
{
}

/**
 * Gets e (the base of natural logarithms) raised to a power.
 * @param {Number} number numeric expression representing the power of e
 * @return {Number} T (the base of natural logarithms) raised to a supplied power.
 */
Math.exp = function (number)
{
}

/**
 * Gets the greatest integer less than or equal to its numeric argument.
 * @param {Number} number Any numeric expression
 * @return {Number} The greatest integer less than or equal to its numeric argument.
 */
Math.floor = function (number)
{
}

/**
 * Gets the natural logarithm of a number.
 * @param {Number} number A numeric expression for which the natural logarithm is sought
 * @return {Number} The natural logarithm of a number.
 */
Math.log = function (number)
{
}

/**
 * Gets the greater of zero or more supplied numeric expressions.
 * @syntax Math.max([number1[, number2[. . . [, numberN]]]])
 * @arguments {Number} [0-n] Numeric expressions to be evaluated
 * @return {Number} The greater of zero or more supplied numeric expressions.
 */
Math.max = function ()
{
}

/**
 * Gets the lesser of zero or more supplied numeric expressions.
 * @syntax Math.min([number1[, number2[. . . [, numberN]]]])
 * @arguments {Number} [0-n] Numeric expressions to be evaluated
 * @return {Number} The lesser of zero or more supplied numeric expressions.
 */
Math.min = function ()
{
}

/**
 * Gets the value of a base expression taken to a specified power.
 * @param {Number} base The base value of the expression
 * @param {Number} exponent The exponent value of the expression
 * @return {Number} The value of a base expression taken to a specified power.
 */
Math.pow = function (base, exponent)
{
}

/**
 * Gets a pseudorandom number between 0 and 1.
 * @return {Number} A pseudorandom number between 0 and 1.
 */
Math.random = function ()
{
}

/**
 * Gets a supplied numeric expression rounded to the nearest integer.
 * @param {Number} number The value to be rounded to the nearest integer
 * @return {Number} The supplied numeric expression rounded to the nearest integer.
 */
Math.round = function (number)
{
}

/**
 * Gets the sine of a number.
 * @param {Number} number A numeric expression for which the sine is needed.
 * @return {Number} The sine of a number.
 */
Math.sin = function (number)
{
}

/**
 * Gets the square root of a number.
 * @param {Number} number A numeric expression for which the square root is needed.
 * @return {Number} The square root of a number.
 */
Math.sqrt = function (number)
{
}

/**
 * Gets the tangent of a number.
 * @param {Number} number A numeric expression for which the tangent is needed.
 * @return {Number} The tangent of a number.
 */
Math.tan = function (number)
{
}



/**
 * Provides functionality common to all JScript objects.
 * @class
 */
function Object()
{
}

/**
 * A reference to the prototype for a class of objects.
 * @type {Object}
 */
Object.prototype.prototype = Object.prototype.prototype;

/**
 * Specifies the function that creates an object.
 * @type {Function}
 */
Object.prototype.constructor = Object.prototype.constructor;

/**
 * Gets an object converted to a string using the current locale.
 * @returns {String} The current object converted to a string using the current locale.
 */
Object.prototype.toLocaleString = function ()
{
}

/**
 * Gets a string representation of an object.
 * @returns {String} The current object converted to a string.
 */
Object.prototype.toString = function ()
{
}

/**
 * Gets the primitive value of the specified object.
 * <p>The valueOf method is defined differently for each intrinsic JScript object.</p>
 * <table class="definition">
 * <col class="term"/>
 * <col class="description"/>
 * <tr>
 * <th class="term">Object</th>
 * <th class="definition">Return Value</th>
 * </tr>
 * <tr><td class="term">Array</td>
 * <td>The elements of the array are converted into strings, and the strings are concatenated together,
 * separated by commas. This behaves the same as the <c>Array.toString</c> and <c>Array.join</c> methods.</td></tr>
 * <tr><td class="term">Boolean</td>
 * <td>The Boolean value.</td></tr>
 * <tr><td class="term">Date</td>
 * <td>The stored time value in milliseconds since midnight, January 1, 1970 UTC.</td></tr>
 * <tr><td class="term">Function</td>
 * <td>The function itself.</td></tr>
 * <tr><td class="term">Number</td>
 * <td>The numeric value.</td></tr>
 * <tr><td class="term">Object</td>
 * <td>The object itself. This is the default.</td></tr>
 * <tr><td class="term">String</td>
 * <td>The string value.</td></tr>
 * </table>
 * <p>The <c>Math</c> and <c>Error</c> objects do not have a valueOf method.</p>
 * @returns {Object} The current object converted to a string.
 */
Object.prototype.valueOf = function ()
{
}

/**
 * An intrinsic global object that stores information about the results of regular expression pattern matches.
 * Available flags, which may be combined, are:
 * <ul>
 * <li><b>g</b> (global search for all occurrences of pattern)</li>
 * <li><b>i</b> (ignore case)</li>
 * <li><b>m</b> (multiline search)</li>
 * </ul>
 * @param {String} pattern The regular expression pattern to use.
 * @param {String} flags Combination of available flags.
 * @class
 */
function RegExp(pattern, flags)
{
}

/** The first most-recently memorized portion found during pattern matching. Read-only */
RegExp.$1 = RegExp.$1;
/** The second most-recently memorized portion found during pattern matching. Read-only */
RegExp.$2 = RegExp.$2;
/** The third most-recently memorized portion found during pattern matching. Read-only */
RegExp.$3 = RegExp.$3;
/** The fourth most-recently memorized portion found during pattern matching. Read-only */
RegExp.$4 = RegExp.$4;
/** The fifth most-recently memorized portion found during pattern matching. Read-only */
RegExp.$5 = RegExp.$5;
/** The sixth most-recently memorized portion found during pattern matching. Read-only */
RegExp.$6 = RegExp.$6;
/** The seventh most-recently memorized portion found during pattern matching. Read-only */
RegExp.$7 = RegExp.$7;
/** The eighth most-recently memorized portion found during pattern matching. Read-only */
RegExp.$8 = RegExp.$8;
/** The ninth most-recently memorized portion found during pattern matching. Read-only */
RegExp.$9 = RegExp.$9;

/** The character position where the first successful match begins in a searched string. Read-only */
RegExp.index = RegExp.index;
/** a.k.a. ($_) the string against which a regular expression search was performed. Read-only */
RegExp.input = RegExp.input;
/** The character position where the next match begins in a searched string */
RegExp.lastIndex = RegExp.lastIndex;
/** a.k.a. ($&) The last matched characters from any regular expression search. Read-only */
RegExp.lastMatch = RegExp.lastMatch;
/** a.k.a. ($+) The last parenthesized submatch from any regular expression search, if any. Read-only */
RegExp.lastParen = RegExp.lastParen;
/** a.k.a. ($`) The characters from the beginning of a searched string up to the position before the beginning of the last match. Read-only. */
RegExp.leftContext = RegExp.leftContext;
/** a.k.a. ($') The characters from the position following the last match to the end of the searched string. Read-only. */
RegExp.rightContext = RegExp.rightContext;


/**
 * Allows manipulation and formatting of text strings and determination and location of substrings within strings.
 * <p><b>String</b> objects can be created implicitly using string literals. <b>String</b> objects created in this fashion
 * (referred to as standard strings) are treated differently than String objects created using the <b>new</b> operator.
 * All string literals share a common, global string object. If a property is added to a string literal, it is available
 * to all standard string objects:</p>
 * <code>var alpha, beta;<br/>
 * alpha = "This is a string";<br/>
 * beta = "This is also a string";<br/><br/>
 * alpha.test = 10;</code>
 * <p>In the previous example, test is now defined for beta and all future string literals. In the following example, however,
 * added properties are treated differently: </p>
 * <code>var gamma, delta;<br/>
 * gamma = new String("This is a string");<br/>
 * delta = new String("This is also a string");<br/><br/>
 * gamma.test = 10;</code>
 * <p>In this case, <i>test</i> is not defined for <i>delta</i>. Each <b>String</b> object declared as a <b>new String</b> object
 * has its own set of members. This is the only case where <b>String</b> objects and string literals are handled differently.
 * @param {String} stringLiteral Any group of Unicode characters.
 * @class
 */
function String(stringLiteral)
{
}

String.prototype = new Object;

/** The length of (number of characters in) a String object.  */
String.prototype.length = String.prototype.length;

/**
 * Gets the character at the specified index.
 * <p>The <b>charAt</b> method returns a character value equal to the character at the specified <i>index</i>.
 * The first character in a string is at index 0, the second is at index 1, and so forth.
 * Values of <i>index</i> out of valid range return an empty string.</p>
 * @param {Number} index Zero-based index of the desired character. Valid values are between 0 and the length of the string minus 1.
 * @return {String} The character at the specified index.
 */
String.prototype.charAt = function (index)
{
}

/**
 * Gets an integer representing the Unicode encoding of the character at the specified location.
 * <p>The first character in a string is at index 0, the second is at index 1, and so forth.</p>
 * <p>If there is no character at the specified index, <b>NaN</b> is returned</p>
 * @param {Number} index Zero-based index of the desired character. Valid values are between 0 and the length of the string minus 1.
 * @return {Number} An integer representing the Unicode encoding of the character at the specified location
 */
String.prototype.charCodeAt = function (index)
{
}

/**
 * Gets a string value containing the concatenation of two or more supplied strings.
 * <p>The result of the concat method is equivalent to: <i>result</i> = <i>string1</i> + <b>string2</b> + <b>string3</b> + ... + <i>stringN</i>.
 * A change of value in either a source or result string does not affect the value in the other string.
 * If any of the arguments are not strings, they are first converted to strings before being concatenated to string1.</p>
 * @arguments {String} [0-n] String objects or literals to concatenate to the end of <i>string1</i>.
 * @syntax string1.concat([string2[, string3[, ... [, stringN]]]])
 * @return {String} A string value containing the concatenation of two or more supplied strings.
 */
String.prototype.concat = function ()
{
}

/**
 * Gets a string from a number of Unicode character values.
 * @syntax String.fromCharCode([code1[, code2[, ... [, codeN]]]])
 * @arguments {Number} [0-n] Optional. A series of Unicode character values to convert to a string.
 * If no arguments are supplied, the result is the empty string.
 * @return {String} A string from a number of Unicode character values.
 */
String.fromCharCode = function ()
{
}

/**
 * Gets the character position where the first occurrence of a substring occurs within a String object.
 * @syntax stringObj.indexOf(subString[, startIndex])
 * @param {String} substring Required. Substring to search for within the String object.
 * @param {Number} startIndex Optional. Integer value specifying the index to begin searching within the String object.
 * If omitted, searching starts at the beginning of the string.
 * @return {Number} The character position where the first occurrence of a substring occurs within a String object.
 */
String.prototype.indexOf = function (substring, startIndex)
{
}

/**
 * Gets the last occurrence of a substring within a String object.
 * <p>The <b>lastIndexOf</b> method returns an integer value indicating the beginning of the substring within the <b>String</b> object.
 * If the substring is not found, a -1 is returned.</p>
 * <p>If <i>startindex</i> is negative, <i>startindex</i> is treated as zero. If it is larger than the greatest character position index,
 * it is treated as the largest possible index.</p>
 * <p>Searching is performed right to left. Otherwise, this method is identical to <b>indexOf</b>.</p>
 * @param {String} substring Required. The substring to search for within the String object.
 * @param {Number} startIndex Integer value specifying the index to begin searching within the String object.
 * If omitted, searching begins at the end of the string
 * @return {Number} The index position of the last occurrence of a substring within a String object.
 */
String.prototype.lastIndexOf = function (substring, startIndex)
{
}

/**
 * Executes a search on a string using a regular expression pattern, and returns an array containing the results of that search.
 * <p>If the match method does not find a match, it returns null. If it finds a match, match returns an array, and the properties
 * of the global RegExp object are updated to reflect the results of the match.</p>
 * <p>The array returned by the match method has three properties, input, index and lastIndex. The input property contains the entire
 * searched string. The index property contains the position of the matched substring within the complete searched string.
 * The lastIndex property contains the position following the last character in the last match.</p>
 * <p>If the global flag (g) is not set, Element zero of the array contains the entire match, while elements 1 – n contain any
 * submatches that have occurred within the match. This behavior is identical to the behavior of the exec method without the
 * global flag set. If the global flag is set, elements 0 - n contain all matches that occurred.</p>
 * @param {RegExp} regExp Required. An instance of a Regular Expression object containing the regular expression pattern and applicable flags.
 * Can also be a variable name or string literal containing the regular expression pattern and flags.
 * @return {Array} Search results.
 */
String.prototype.match = function (regExp)
{
}

/**
 * Gets a copy of a string with text replaced using a regular expression or search string.
 * <p>The result of the replace method is a copy of stringObj after the specified replacements have been made.</p>
 * <p>Any of the following match variables can be used to identify the most recent match and the string from which it came.
 * The match variables can be used in text replacement where the replacement string has to be determined dynamically.</p>
 * <ul><style>.ch { font-weight: bold; height: 16px; width: 40px; text-align: right; margin-right: 10px }</style>
 * <li><span class="ch">$$</span><b>$</b></li>
 * <li><span class="ch">$&</span>Specifies that portion of <i>stringObj</i> that the entire pattern matched.</li>
 * <li><span class="ch">$`</span>Specifies that portion of <i>stringObj</i> that precedes the match described by <b>$&</b>.</li>
 * <li><span class="ch">$'</span>Specifies that portion of <i>stringObj</i> that follows the match described by <b>$&</b>.</li>
 * <li><span class="ch">$n</span>The <i>n</i>th captured submatch, where <i>n</i> is a single decimal digit from 1 through 9.</li>
 * <li><span class="ch">$nn</span>The <i>nn</i>th captured submatch, where <i>nn</i> is a two-digit decimal number from 01 through 99.</li>
 * </ul>
 * <p>If <i>replaceText</i> is a function, for each matched substring the function is called with the following <i>m</i> + 3 arguments where
 * <i>m</i> is the number of left capturing parentheses in the rgExp. The first argument is the substring that matched.
 * The next <i>m</i> arguments are all of the captures that resulted from the search. Argument <i>m</i> + 2 is the offset within <i>stringObj</i>
 * where the match occurred, and argument <i>m</i> + 3 is <i>stringObj</i>. The result is the string value that results from replacing each
 * matched substring with the corresponding return value of the function call.</p>
 * The <b>replace</b> method updates the properties of the global <b>RegExp</b> object
 * @param {RegExp} regExp Required. An instance of a Regular Expression object containing the regular expression pattern and applicable flags.
 * Can also be a String object or literal. If rgExp is not an instance of a Regular Expression object, it is converted to a string,
 * and an exact search is made for the results; no attempt is made to convert the string into a regular expression.
 * @param {String} replaceText Required. A String object or string literal containing the text to replace for every successful match of rgExp
 * in stringObj. In JScript 5.5 or later, the replaceText argument can also be a function that returns the replacement text.
 * @return {String} A copy of a string with text replaced using a regular expression or search string.
 */
String.prototype.replace = function (regExp, replaceText)
{
}

/**
 * Gets the position of the first substring match in a regular expression search.
 * The search method indicates if a match is present or not. If a match is found, the search method returns an integer value that
 * indicates the offset from the beginning of the string where the match occurred. If no match is found, it returns -1.
 * @param {RegExp} regExp Required. An instance of a Regular Expression object containing the regular expression pattern and applicable flags.
 * @return {Number} The position of the first substring match in a regular expression search
 */
String.prototype.search = function (regExp)
{
}

/**
 * Gets a section of a string.
 * <p>The <b>slice</b> method returns a <b>String</b> object containing the specified portion of <i>stringObj</i>.</p>
 * <p>The <b>slice</b> method copies up to, but not including, the element indicated by <i>end</i>. If <i>start</i> is negative, it is treated as
 * <i>length</i> + <i>start</i> where <i>length</i> is the <i>length</i> of the string. If <i>end</i> is negative, it is treated as
 * <i>length</i> + <i>end</i> where <i>length</i> is the length of the string. If <i>end</i> is omitted, extraction continues to the
 * end of <i>stringObj</i>. If <i>end</i> occurs before start, no characters are copied to the new string.</p>
 * @syntax stringObj.slice(start, [end])
 * @param {Number} start Required. The index to the beginning of the specified portion of stringObj.
 * @param {Number} end Optional. The index to the end of the specified portion of stringObj.
 * @return {String} The characters between start and end index positions.
 */
String.prototype.slice = function (start, end)
{
}

/**
 * Gets the array of strings that results when a string is separated into substrings.
 * <p>The result of the <b>split</b> method is an array of strings split at each point where <i>separator</i> occurs in <i>stringObj</i>.
 * The <i>separator</i> is not returned as part of any array element.</p>
 * @syntax stringObj.split([separator[, limit]])
 * @param {String} separator Optional. A string or an instance of a <b>Regular Expression</b> object identifying one or more characters to
 * use in separating the string. If omitted, a single-element array containing the entire string is returned.
 * @param {Number} limit Optional. A value used to limit the number of elements returned in the array.
 * @return {Array} Array of strings that results when a string is separated into substrings
 */
String.prototype.split = function (separator, limit)
{
}

/**
 * Gets a substring beginning at a specified location and having a specified length.
 * <p>If <i>length</i> is zero or negative, an empty string is returned. If not specified, the substring continues to the end of
 * <i>stringObj</i>.</p>
 * @syntax stringObj.substr(start [, length ])
 * @param {Number} start Required. The starting position of the desired substring. The index of the first character in the string is zero.
 * @param {Number} end Optional. The number of characters to include in the returned substring.
 * @return {String} Substring beginning at a specified location and having a specified length
 */
String.prototype.substr = function (start, end)
{
}

/**
 * Gets the substring at the specified location within a String object.
 * <p>The <b>substring</b> method returns a string containing the substring from <i>start</i> up to, but not including, <i>end</i>.</p>
 * <p>The <b>substring</b> method uses the lower value of <i>start</i> and <i>end</i> as the beginning point of the substring.
 * For example, <i>strvar</i><b>.substring(0, 3)</b> and <i>strvar</i><b>.substring(3, 0)</b> return the same substring.</p>
 * <p>If either <i>start</i> or <i>end</i> is <b>NaN</b> or negative, it is replaced with zero.</p>
 * <p>The length of the substring is equal to the absolute value of the difference between <i>start</i> and <i>end</i>.
 * For example, the length of the substring returned in <i>strvar</i><b>.substring(0, 3)</b> and <i>strvar</i><b>.substring(3, 0)</b> is three.</p>
 * @syntax strVariable.substring(start, end)
 * @param {Number} start The zero-based index integer indicating the beginning of the substring.
 * @param {Number} end The zero-based index integer indicating the end of the substring.
 * @return {String} The substring at the specified location within a String object.
 */
String.prototype.substring = function (start, end)
{
}

/**
 * Gets a string where all alphabetic characters have been converted to lowercase.
 * @return {String} string with all alphabetic characters converted to lowercase.
 */
String.prototype.toLowerCase = function ()
{
}

/**
 * Gets a string where all alphabetic characters have been converted to uppercase.
 * @return {String} string with all alphabetic characters converted to uppercase.
 */
String.prototype.toUpperCase = function ()
{
}

